home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / logicsim.arc / LOGICSIM.INC < prev    next >
Text File  |  1986-01-08  |  20KB  |  1,008 lines
  1. { Include File for Logic Simulator }
  2. { APRIL 1985                       }
  3.  
  4. Procedure WriteHeader;
  5. begin
  6.   Writeln(Device);  Writeln(Device);
  7.   Writeln(Device,Header);
  8.   Writeln(Device);
  9. end;
  10.  
  11. Procedure GetQintoXQ;
  12. begin
  13.   OLD[0]:=LNOT[OLD[Q1]];  XQ:=OLD[Q0];
  14. end;
  15.  
  16. Procedure StoreQandNotQ;
  17. begin
  18.   NEW[Q0]:=Y;
  19.   NEW[Q1]:=LNOT[Y];
  20. end;
  21.  
  22. Procedure MuxFunction;
  23. begin
  24.   Y:= (Y0 And LNOT[YC]) Or (Y1 And YC) Or (Y0 and Y1);
  25.   if Y<>0 then Y:=3;
  26. end;
  27.  
  28. Procedure SetAndResetFunction;
  29. begin
  30.   Y:= (Y Or LNOT[XSS]) And XR;
  31.   if Y<>0 then Y:=3;
  32. end;
  33.  
  34. Procedure ShiftRegisterFCN;
  35. begin
  36.   Y0:=XD;  YC:=XC;  Y1:=XL;
  37.   MuxFunction;
  38.   SetAndResetFunction;
  39.   YL:=Y;  Y0:=XQ;
  40.   MuxFunction;
  41.   SetAndResetfunction;
  42. end;
  43.  
  44. Procedure MuxAndDFF;
  45. begin
  46.   Y0:= D0; Y1:= D1; YC:=XM;
  47.   MuxFunction;
  48.   XD:=Y;
  49.   ShiftRegisterFCN;
  50. end;
  51.  
  52. Procedure AndGate;
  53. begin
  54.   OLD[0]:=L1; Y:=L1;
  55.   for I:=1 to 5 do
  56.   begin
  57.     Y:= Y and OLD[INPUT[I]];
  58.     if Y<>0 then Y:=3;
  59.   end;
  60. end;
  61.  
  62. Procedure NandGate;
  63. begin
  64.   X:=Q0;  Q0:=Q1;  Q1:=X;
  65.   AndGate;
  66. end;
  67.  
  68. Procedure OrGate;
  69. begin
  70.   OLD[0]:=L0; Y:=L0;
  71.   for I:=1 to 5 do
  72.   begin
  73.     Y:= Y or OLD[INPUT[I]];
  74.     if Y<>0 then Y:=3;
  75.   end;
  76. end;
  77.  
  78. Procedure NorGate;
  79. begin
  80.   X:=Q0;  Q0:=Q1;  Q1:=X;
  81.   OrGate;
  82. end;
  83.  
  84. Procedure XorGate;
  85. begin
  86.   OLD[0]:=LX;
  87.   Y0:=OLD[INPUT[1]];  Y1:=LNOT[Y0];  YC:=OLD[INPUT[2]];
  88.   MuxFunction;
  89. end;
  90.  
  91. Procedure XNorGate;
  92. begin
  93.   X:=Q0;  Q0:=Q1;  Q1:=X;
  94.   XorGate;
  95. end;
  96.  
  97. Procedure DFlipFlop;
  98. begin
  99.   GetQintoXQ;
  100.   OLD[0]:=LX;  XD:=OLD[INPUT[1]];  XC:=OLD[INPUT[3]];
  101.   XL:=LO[L,8]; OLD[0]:=L1; XR:=OLD[INPUT[4]]; XSS:=OLD[INPUT[5]];
  102.   ShiftRegisterFCN;
  103.   LO[L,8]:=YL;
  104. end;
  105.  
  106. Procedure JKFlipFlop;
  107. begin
  108.   GetQintoXQ;
  109.   XM:=XQ;  OLD[0]:=LX;  XC:=OLD[INPUT[3]];
  110.   D0:=OLD[INPUT[1]];  D1:=LNOT[OLD[INPUT[2]]];
  111.   OLD[0]:=L1;  XR:=OLD[INPUT[4]];
  112.   XSS:=OLD[INPUT[5]];  XL:=LO[L,8];
  113.   MuxAndDFF;
  114.   LO[L,8]:=YL;
  115. end;
  116.  
  117. Procedure ParallelLoadCounter;
  118. Label DoAgain;
  119. begin
  120.   OLD[0]:=LX;  YE:=OLD[INPUT[2]];  XC:=OLD[INPUT[3]];
  121.   OLD[0]:=L0;  XM:=OLD[INPUT[4]];
  122.   OLD[0]:=L1;  XR:=OLD[INPUT[5]];  XSS:=L1;
  123.   DoAgain:
  124.   GetQIntoXQ;
  125.   XL:=LO[L,8];
  126.   YC:=YE;  Y0:=XQ;  Y1:=LNOT[Y0];
  127.   MuxFunction;
  128.   D0:=Y;  DL:=OLD[INPUT[1]];
  129.   MuxAndDff;
  130.   LO[L,8]:=YL;
  131.   If TYPES[LO[L+1,0]]='*' then
  132.   begin
  133.     StoreQandNotQ;
  134.     L:=L+1;  INPUT[1]:=LO[L,1];  Q0:=LO[L,6];  Q1:=LO[L,7];
  135.     YE:= YE and Y;
  136.     if YE<>0 then YE:=3;
  137.     goto DoAgain;
  138.   end;
  139. end;
  140.  
  141. Procedure ParallelLoadShiftRegister;
  142. Label DoAgain;
  143. begin
  144.   OLD[0]:=LX;  D0:=OLD[INPUT[2]];  XC:=OLD[INPUT[3]];
  145.   OLD[0]:=L0;  XM:=OLD[INPUT[4]];
  146.   OLD[0]:=L1;  XR:=OLD[INPUT[5]];  XSs:=L1;
  147.  DoAgain:
  148.   OLD[0]:=LX;  D1:=OLD[INPUT[1]];
  149.   GetQintoXQ;
  150.   XL:=LO[L,8];
  151.   MuxAndDFF;
  152.   LO[L,8]:=YL;
  153.   if TYPES[LO[L+1,0]]='*' then
  154.   begin
  155.     StoreQandNotQ;
  156.     L:=L+1;  INPUT[1]:=LO[L,1];  Q0:=LO[L,6];  Q1:=LO[L,7];  D0:=Y;
  157.     GOTO DoAgain;
  158.   end;
  159. end;
  160.  
  161. Procedure NBitShiftRegister;
  162. begin
  163.   if INPUT[2]=0 then DFlipFlop;
  164.   OLD[0]:=LX;  XD:=OLD[INPUT[1]];  XC:=OLD[INPUT[3]];
  165.   OLD[0]:=L1;  XR:=OLD[INPUT[4]];  XSS:=OLD[INPUT[5]];
  166.   M1:=LO[L,8];
  167.   For I:=1 to -INPUT[2] do
  168.   begin
  169.     XL:=ME[M1,0];  XQ:=ME[M1,1];
  170.     ShiftRegisterFCN;
  171.     XD:=XQ;  ME[M1,0]:=YL;  ME[M1,1]:=Y;
  172.     M1:=M1+1
  173.   end;
  174. end;
  175.  
  176. Procedure SimulateThisGate;
  177. begin
  178.   LT:=LO[L,0];
  179.   for I:=1 to 5 do
  180.   begin
  181.     INPUT[I]:=LO[L,I];
  182.   end;
  183.   Q0:=LO[L,6];  Q1:=LO[L,7];
  184.   if LT=1 then AndGate;
  185.   if LT=2 then NandGate;
  186.   if LT=3 then OrGate;
  187.   if LT=4 then NorGate;
  188.   if LT=5 then XorGate;
  189.   if LT=6 then XnorGate;
  190.   if LT=7 then DFlipFlop;
  191.   if LT=8 then JKFlipFlop;
  192.   if LT=9 then ParallelLoadCounter;
  193.   if LT=10 then ParallelLoadShiftRegister;
  194.   if LT=11 then NBitShiftRegister;
  195.  
  196.   StoreQandNotQ;
  197. end;
  198.  
  199. Procedure SimulateGates;
  200. Label NoSim;
  201. begin
  202.   if C9<>0 then
  203.   begin
  204.     L:=SLGIC;
  205.     repeat
  206.       if STF<>0 then if S0[L]=0 then GOTO NoSim;
  207.       SimulateThisGate;
  208. NoSim:
  209.       L:=L+1;
  210.     until L>NLGIC;
  211.   end;
  212. end;
  213.  
  214. Procedure LookUpSignalName;
  215. begin
  216.   FOUND:=-1;
  217.   if Xs= ' ' then Xs:='0';
  218.   if Copy(Xs,1,1)<>'#' then
  219.   begin
  220.     for II:=0 to NNAM do
  221.     begin
  222.       if Xs= NAMES[II] then FOUND:=II;
  223.     end;
  224.   end;
  225.   if Copy(Xs,1,1)='#' then
  226.   begin
  227.     XXs:=Copy(Xs,2,length(Xs)-1);
  228.     Val(XXs,FOUND,ERROR);
  229.     FOUND:= -FOUND;
  230.     if FOUND=-1 then FOUND:=0;
  231.   end;
  232. end; {of LookUpSignalName}
  233.  
  234. Procedure EnterChanges;
  235. Label Change1;
  236. begin
  237.   ClrScr;
  238.   Writeln('As each Current Sample Node is displayed, hit');
  239.   Writeln('RETURN for no change, or New Name to change.');
  240.   for I:=1 to SCREEN do
  241.   begin
  242.   Change1:
  243.     Xs:='';
  244.       Write(NAMES[SAMPLED[I]],' '); Readln(Xs);
  245.       for II:=1 to length(Xs) do
  246.       begin
  247.         Insert(UpCase(Copy(Xs,II,1)),Xs,II);
  248.         Delete(Xs,II+1,1);
  249.       end;
  250.       if Xs<>'' then
  251.       begin
  252.         LookUpSignalName;
  253.         if FOUND=-1 then GOTO Change1;
  254.         SAMPLED[I]:=FOUND;
  255.       end;
  256.       if SAMPLED[I]<>0 then NSAMPLED:=I;
  257.   end;
  258. end;
  259.  
  260. Procedure CalcXY;
  261. Var       PXX,PYY:      Real;
  262. begin
  263.   PYY:=INT((X+XO) div LINE);
  264.   PXX:=(X+XO)-PYY*LINE;
  265.   PX:=Round(PXX)+1; PY:=Round(PYY)+1;
  266.   XO:=0;
  267.   GotoXY(PX,PY);
  268. end;
  269.  
  270. Procedure FullScreen;
  271. begin
  272.   TIME:=TIME-INCREMENT;
  273.   GotoXY(20,1);
  274.   Write('Change, Reset, Quit, or any other key to continue ');
  275.   Read(ASK); ASK:=ASK+' ';
  276.   ASK:=upcase(copy(ASK,1,1));
  277.   PC:=0; ClrScr;
  278.   if ASK='C' then EnterChanges;
  279. end;
  280.  
  281. Procedure PrintTicMarks;
  282. begin
  283.   XO:=0;
  284.   for X:=91 to 156 do
  285.   begin
  286.     CalcXY; Write('''');
  287.   end;
  288.   X:=91;
  289.   for I:=1 to 7 do
  290.   begin
  291.     CalcXY; Write(':');
  292.     XO:=5;
  293.     CalcXY; Write('|');
  294.     X:=X+10;
  295.   end;
  296. end;
  297.  
  298. Procedure PrintValuesDownColumn;
  299. begin
  300.   X:=PC+LINE*2;
  301.   for I:=1 to NSAMPLED do
  302.   begin
  303.     Y:=OLD[SAMPLED[I]];
  304.     CalcXY; Write(LOGPR[Y]);
  305.     X:=X+LINE;
  306.   end;
  307. end;
  308.  
  309. Procedure SetUpDisplay;
  310. begin
  311.   PC:=11;
  312.   ClrScr;
  313.   PrintTicMarks;
  314.   GotoXY(5,1); Write('Time');
  315.   GotoXY(12,1); Write(RI);
  316.   X:=LINE*2;
  317.   for I:=1 to NSAMPLED do
  318.   begin
  319.     CalcXY; Write(NAMES[SAMPLED[I]]);
  320.     X:=X+LINE;
  321.   end;
  322. end;
  323.  
  324. Procedure DisplayLogicValues;
  325. begin
  326.   GotoXY(70,0); Write(RI:8);
  327.   if TIME=RI then
  328.   begin
  329.     if  PC=0 then SetUpDisplay;
  330.     PrintValuesDownColumn;
  331.     TIME:=TIME+INCREMENT;
  332.     PC:=PC+1;
  333.     if PC>LINE-4 then FullScreen;
  334.   end;
  335. end;
  336.  
  337. Procedure ReadAndParse;
  338. begin
  339.   if not EOF(filvar) then
  340.   begin
  341.     readln(filvar,Ls);
  342.     for I:=1 to length(Ls) do
  343.     begin
  344.       Insert(UpCase(Copy(Ls,I,1)),Ls,I);
  345.       Delete(Ls,I+1,1);
  346.     end;
  347.     LI:=0;
  348.     repeat
  349.       I:=pos(' ',Ls);
  350.       if I<>0 then
  351.       begin
  352.         LIs[LI]:= copy(Ls,1,I-1);
  353.         Ls:=copy(Ls,I,length(Ls)-I+1);
  354.         LI:=LI+1;
  355.         while copy(Ls,1,1)=' ' do Ls:=copy(Ls,2,length(Ls)-1);
  356.       end;
  357.     until I=0;
  358.     LIs[LI]:=Ls;
  359.     for I:= LI+1 to 10 do
  360.     begin
  361.       LIs[I]:=' ';
  362.     end;
  363.   end;
  364. end; {of ReadandParse}
  365.  
  366. Procedure LookUpType;
  367. begin
  368.   FOUND:=-1;
  369.   For II:= 0 to NTYPE-1 do
  370.   begin
  371.     if Xs= TYPES[II] then
  372.     begin
  373.       FOUND:= II;
  374.       TPTR:= TYPEX[II];
  375.     end;
  376.   end;
  377. end; {of LookUpType}
  378.  
  379. Procedure AddType;
  380. begin
  381.   if FOUND=-1 then
  382.   begin
  383.     FOUND:=NTYPE;
  384.     NTYPE:=NTYPE+1;
  385.   end;
  386.   if FOUND>NTYPE then NTYPE:=FOUND;
  387.   TYPES[FOUND]:=Xs;
  388.   TYPEX[FOUND]:=TPTR;
  389. end; {of AddType}
  390.  
  391. Procedure AddNameToList;
  392. begin
  393.   if FOUND= -1 then
  394.   begin
  395.     FOUND:= NNAM;
  396.     NNAM:= NNAM+1;
  397.   end;
  398.   if FOUND > NNAM then NNAM:= FOUND +1;
  399.   NAMES[FOUND]:= Xs;
  400. end; {of AddNameToList}
  401.  
  402. Procedure AddT0thruT9toExternalArray;
  403. begin
  404.   for II:=0 to 9 do
  405.   begin
  406.     EX[NE,II]:=T[II];
  407.   end;
  408.   write(Device,TEX[EX[NE,0]]:3,' ',NAMES[EX[NE,1]]:15,LOGIN[EX[NE,2]]:5);
  409.   for II:=3 to 9 do
  410.   begin
  411.     Write(Device,EX[NE,II]:5);
  412.   end;
  413.   Writeln(Device);
  414.   NE:=NE+1;
  415. end;
  416.  
  417. Procedure AddT0thruT7toLogicArray;
  418. begin
  419.   for II:= 0 to 7 do
  420.   begin
  421.     LO[NLGIC,II]:=T[II];
  422.   end;
  423.   Write(Device,TYPES[LO[NLGIC,0]]:10);
  424.   for II:= 1 to 7 do
  425.   begin
  426.     XX:=LO[NLGIC,II];
  427.     if XX<0  then write(Device,'   #',-XX);
  428.     if XX>=0 then write(Device,NAMES[XX]:8);
  429.   end;
  430.   Writeln(Device);
  431.   NLGIC:=NLGIC+1;
  432. end; {of AddT0thruT7toLogicArray}
  433.  
  434. Procedure ClearOldArray;
  435. begin
  436.   for I:=0 to MNAMS do
  437.   begin
  438.     OLD[I]:=0;
  439.   end;
  440.   TL:=0;
  441. end; {of ClearOldArray}
  442.  
  443. Procedure IgnoreErrorOption;
  444. begin
  445.   Write('Enter (I)gnore to ignore Error');
  446.   Readln(ASK); ASK:=ASK+' ';
  447.   ASK:= upcase(copy(ASK,1,1));
  448.   if ASK<>'I' then ERROR:=1;
  449. end; {of IgnoreErrorOption}
  450.  
  451. Procedure MultipleDefinition;
  452. begin
  453.   Writeln('ERROR: Multiple Definition of Output ',NAMES[X]);
  454.   IgnoreErrorOption;
  455. end; {of MultipleDefinition}
  456.  
  457. Procedure MarkOutputsAndCheckForDupes;
  458. begin
  459.   if X<>0 then
  460.   begin
  461.     if OLD[X]<>0 then MultipleDefinition;
  462.     OLD[X]:=1;
  463.   end;
  464. end; {of MarkOutputsAndCheckForDupes}
  465.  
  466. Procedure CheckForMultipleOutputs;
  467. begin
  468.   X1:=STF;
  469.   for I:= X1 to NLGIC-1 do
  470.   begin
  471.     for J:= 6 to 7 do
  472.     begin
  473.       X:=LO[I,J];
  474.       MarkOutputsAndCheckForDupes;
  475.     end;
  476.   end;
  477. end; {of CheckForMultipleOutputs}
  478.  
  479. Procedure UndefinedInput;
  480. begin
  481.   Writeln('Undefined Input: ',NAMES[X]);
  482.   IgnoreErrorOption;
  483. end; {of UndefinedInput}
  484.  
  485. Procedure CheckForMark;
  486. begin
  487.   if X>0 then
  488.   begin
  489.     if OLD[X]=0 then UndefinedInput;
  490.     OLD[X]:=OLD[X]+1;
  491.     TL:=TL+1;
  492.   end;
  493. end; {of CheckForMark}
  494.  
  495. Procedure CheckForDefinedInputs;
  496. begin
  497.   X1:=STF;
  498.   for I:=X1 to NLGIC-1 do
  499.   begin
  500.     for J:=1 to 5 do
  501.     begin
  502.       X:=LO[I,J];
  503.       CheckForMark;
  504.       if X<0 then MM:=MM-X;
  505.     end;
  506.   end;
  507. end; {of CheckForDefinedInputs}
  508.  
  509.  
  510. Procedure MisMatch;
  511. begin
  512.   Writeln('Mis-Match on Macro call -- Can''t Continue');
  513.   Close(Filvar);
  514.   HALT;
  515. end;
  516.  
  517. Procedure DeleteCurrentLine;
  518. begin
  519.   NLGIC:=NLGIC-1;
  520.   for K:=LOx to NLGIC-1 do
  521.   begin
  522.     for K1:=0 to 8 do
  523.     begin
  524.       LO[K,K1]:=LO[K+1,K1];
  525.     end;
  526.   end;
  527. end; {of DeleteCurrentLine}
  528.  
  529. Procedure BuildMacroCorrespondenceArray;
  530. begin
  531.   LOx:=I; X:=LO[I,0]; J:=TYPEX[X]; Y:=LO[J,0]; M1:=J; OLD[0]:=0;
  532.   Header:='Expansion of call to Macro: '+TYPES[X];
  533.   WriteHeader;
  534.   for K:=1 to MNAMS do
  535.   begin
  536.     OLD[K]:=-1;
  537.   end;
  538.   repeat
  539.     if X<>Y then MisMatch;
  540.     for K:=1 to 5 do
  541.     begin
  542.       I1:=LO[M1,K]; I2:=LO[LOx,K];
  543.       if I1=0  then if I2=0  then OLD[I1]:=I2;
  544.       if I1=0  then if I2<>0 then OLD[I1]:=I2;
  545.       if I1<>0 then if I2<>0 then OLD[I1]:=I2;
  546.     end;
  547.     for K:= 6 to 7 do
  548.     begin
  549.       I1:=LO[M1,K]; I2:=LO[LOx,K];
  550.       if I1=0  then if I2=0  then OLD[I1]:=I2;
  551.       if I1<>0 then if I2=0  then OLD[I1]:=I2;
  552.       if I1<>0 then if I2<>0 then OLD[I1]:=I2;
  553.     end;
  554.     DeleteCurrentLine;
  555.     M1:=M1+1; Y:=LO[M1,0]; X:=LO[LOx,0];
  556.   until TYPES[Y]<>'*';
  557. end; {of BuildMacroCorrespondenceArray}
  558.  
  559. Procedure AddUniqueName;
  560. begin
  561.   OLD[X]:=NNAM;
  562.   Str(NNAM,Xs);
  563.   NAMES[NNAM]:='&'+Xs; {Copy(Xs,2,length(Xs)-1);}
  564.   NNAM:=NNAM+1;
  565. end; {of AddUniqueName}
  566.  
  567. Procedure AddExpandedMacroToElementArray;
  568. begin
  569.   NLGIC:=NLGIC-1;
  570.   repeat
  571.     T[0]:=LO[M1,0];
  572.     for K:= 1 to 7 do
  573.     begin
  574.       X:=LO[M1,K];
  575.       if X<0 then T[K]:=X;
  576.       if X>=0 then
  577.       begin
  578.         if OLD[X]= -1 then AddUniqueName;
  579.         T[K]:=OLD[X];
  580.       end;
  581.     end;
  582.     AddT0thruT7toLogicArray;
  583.     M1:=M1+1;
  584.   until T[0]=0;
  585. end; {of AddExpandedMacroToElementArray}
  586.  
  587. Procedure SetAsideMemForSregs;
  588. begin
  589.   M1:=0;
  590.   for I:=0 to MM do
  591.   begin
  592.     ME[I,0]:=LX;
  593.     ME[I,1]:=LX;
  594.   end;
  595.   for I:=SLGIC to NLGIC do
  596.   begin
  597.     if TYPES[LO[I,0]]='SREG' then
  598.     begin
  599.       LO[I,8]:=M1;
  600.       M1:=M1-LO[I,2];
  601.     end;
  602.   end;
  603. end;
  604.  
  605. Procedure StoreNextSchedule;
  606. begin
  607.   EX[I,10]:=E3;
  608.   if E9>E3 then E9:=E3;
  609. end;
  610.  
  611. Procedure InitializeForSimulation;
  612. begin
  613.   for I:=0 to NNAM do
  614.   begin
  615.     NEW[I]:=LX;
  616.   end;
  617.   for I:=SLGIC to NLGIC do
  618.   begin
  619.     LO[I,8]:=LX;
  620.   end;
  621.   Writeln;
  622.   RI:=0;
  623.   Write('Enter Sample Start Time '); Readln(TIME);
  624.   Write('Enter Increment Time    '); Readln(INCREMENT);
  625.   if INCREMENT=0 then INCREMENT:=1; PC:=0;
  626.   ClrScr;
  627.   E9:=32767;
  628.   for I:=0 to NE do
  629.   begin
  630.     E3:=EX[I,3];
  631.     StoreNextSchedule;
  632.   end;
  633.   if NSAMPLED=0 then EnterChanges;
  634.   if MM<>0 then SetAsideMemForSregs;
  635.   ASK:=' ';
  636. end;
  637.  
  638. Procedure PrintOutLoadTable;
  639. begin
  640.   Header:='Load Table';
  641.   WriteHeader;
  642.   Writeln(Device,'Node         Driven Elements');
  643.   for II:=1 to NNAM do
  644.   begin
  645.     Write(Device,NAMES[II]:10,' ');
  646.     T1:=S1[II];
  647.     while S2[T1]<>-1 do
  648.     begin
  649.       Write(Device,S2[T1]-SLGIC+1:4);
  650.       T1:=T1+1;
  651.     end;
  652.     Writeln(Device);
  653.   end;
  654. end;
  655.  
  656. Procedure BuildSelectiveTraceTable;
  657. begin
  658.   STF:=1;
  659.   Writeln('*****       Building Selective Trace Table');
  660.   T1:=0;
  661.   For I:=1 to NNAM do
  662.   begin
  663.     S1[I]:=T1;
  664.     For J:=SLGIC to NLGIC do
  665.     begin
  666.       For K:=1 to 5 do
  667.       begin
  668.         if LO[J,K]=I then
  669.         begin
  670.           S2[T1]:=J;
  671.           T1:=T1+1;
  672.         end;
  673.       end;
  674.     end;
  675.     S2[T1]:=-1;
  676.     T1:=T1+1;
  677.   end;
  678.   PrintOutLoadTable;
  679. end;
  680.  
  681. Procedure FindNextChange;
  682. Label Chng1,EndChng;
  683. begin
  684.   E0:=EX[I,0];  E1:=EX[I,1];  E2:=EX[I,2];  E3:=EX[I,3];
  685.   Y:=NEW[E1];
  686.   if RI=E3 then Y:=LNOT[E2];
  687.   NEW[E1]:=LNOT[Y];
  688.   if TEX[E0]='P' then
  689.   begin
  690.     E3:=Ex[I,10]+EX[I,4];
  691.     GOTO EndChng;
  692.   end;
  693.   J:=4; E3:=32767;
  694.   Chng1:
  695.   if J>=9 then GOTO EndChng;
  696.   if EX[I,J]<=RI then
  697.   begin
  698.     J:=J+1;
  699.     GOTO Chng1;
  700.   end;
  701.   E3:=EX[I,J];
  702. EndChng:
  703. end;
  704.  
  705. Procedure GetNextScheduledExternal;
  706. begin
  707.   if RI=E9 then
  708.   begin
  709.     E9:=32767;
  710.     for I:=0 to NE do
  711.     begin
  712.       E3:=EX[I,10];
  713.       if E3=RI then FindNextChange;
  714.       StoreNextSchedule;
  715.     end;
  716.   end
  717. end;
  718.  
  719. Procedure ClearSO;
  720. begin
  721.   for II:=SLGIC to NLGIC do
  722.   begin
  723.     S0[II]:=0;
  724.   end;
  725. end;
  726.  
  727. Procedure NoteChange;
  728. begin
  729.   C9:=1;
  730.   OLD[I]:=NEW[I];
  731.   if STF<>0 then
  732.   begin
  733.     II:=S1[I];
  734.     J:=0;
  735.     While J<>-1 do
  736.     begin
  737.       J:=S2[II];
  738.       if J<>-1 then
  739.       begin
  740.         S0[J]:=1; II:=II+1;
  741.       end;
  742.     end;
  743.   end;
  744. end;
  745.  
  746. Procedure MoveNewToOld;
  747. begin
  748.   C9:=0;
  749.   if STF<>0 then ClearSO;
  750.   for I:=1 to NNAM do
  751.   begin
  752.     if NEW[I]<>OLD[I] then NoteChange;
  753.   end;
  754. end;
  755.  
  756. Procedure RecalculateRippletime;
  757. begin
  758.   if C9=1 then RI:=RI+1;
  759.   if C9<>1 then
  760.   begin
  761.     RI:=E9;
  762.     if RI>TIME Then RI:=TIME;
  763.   end;
  764. end;
  765.  
  766. Procedure ReadExternals;
  767. Label BgnExt,EndExt;
  768. begin
  769.   Header:='External Stimuli';
  770.   WriteHeader;
  771.   NE:=0;
  772.   ReadAndParse;
  773.   BgnExt:
  774.     ReadAndParse;
  775.     if LIs[0]='END' then GOTO EndExt;
  776.     for I:=0 to 1 do
  777.     begin
  778.       if LIs[0]=TEX[I] then T[0]:=I;
  779.     end;
  780.     Xs:=LIs[1];
  781.     LookUpSignalName;
  782.   if FOUND=-1 then GOTO BgnExt;
  783.   T[1]:= FOUND;
  784.   for I:= 0 to 3 do
  785.   begin
  786.     if LIs[2]=LOGIN[I] then T[2]:=LV[I];
  787.   end;
  788.   for I:=3 to 9 do
  789.   begin
  790.     val(LIs[I],T[I],J);
  791.     if J<>0 then T[I]:=0;
  792.   end;
  793.   AddT0thruT9toExternalArray;
  794.   GOTO BgnExt;
  795. EndExt:
  796. end; {of ReadExternals}
  797.  
  798. Procedure CheckErrors;
  799. begin
  800.   ClearOldArray;
  801.   MM:=0;
  802.   for I:=0 to NE-1 do    (*----------- this (-1) may be wrong *)
  803.   begin
  804.     OLD[EX[I,1]]:=1;
  805.   end;
  806.   STF:=SLGIC;
  807.   CheckForMultipleOutputs;
  808.   CheckForDefinedInputs;
  809. end; {of CheckErrors}
  810.  
  811. Procedure ReadNodes;
  812. begin
  813.   NSAMPLED:=0;
  814.   ReadAndParse;
  815.   if not Eof(filvar) then
  816.   begin
  817.     repeat
  818.       ReadAndParse;
  819.       for I:=0 to 10 do
  820.       begin
  821.         Xs:=LIs[I];
  822.         if Xs<>' ' then
  823.         begin
  824.           LookUpSignalName;
  825.           if FOUND<>-1 then
  826.           begin
  827.             if NSAMPLED<SCREEN then
  828.             begin
  829.               NSAMPLED:=NSAMPLED+1;
  830.               SAMPLED[NSAMPLED]:=FOUND;
  831.             end;
  832.           end;
  833.         end;
  834.       end;
  835.     until LIs[0]='END';
  836.     for I:=NSAMPLED+1 to SCREEN do
  837.     begin
  838.       SAMPLED[I]:=0;
  839.     end;
  840.   end;
  841. end; {of ReadNodes}
  842.  
  843. Procedure SetUpSimulation;
  844. Label Setup1,Setup2;
  845. begin
  846.   if ERROR=0 then
  847.   begin
  848.     NNAM:=NNAM-1;
  849.     NLGIC:=NLGIC-1;
  850.     NE:=NE-1;
  851.     BuildSelectiveTraceTable;
  852.     SetUp1:
  853.       InitializeForSimulation;
  854.     Setup2:
  855.       GetNextScheduledExternal;
  856.       MoveNewToOld;
  857.       DisplayLogicValues;
  858.     if ASK='R' then GOTO Setup1;
  859.     if ASK<> 'Q' then
  860.     begin
  861.       SimulateGates;
  862.       RecalculateRippleTime;
  863.       GOTO SetUp2;
  864.     end;
  865.   end;
  866. end;
  867.  
  868. Procedure ReadInLogicDescription;
  869. begin
  870.  
  871.   SLGIC:=NLGIC;  NAMES[0]:='0';  NNAM:=1;
  872.   for I:= 1 to MNAMS do
  873.   begin
  874.     NAMES[I]:='';
  875.   end;
  876.   repeat
  877.     ReadAndParse;
  878.     Xs:=LIs[0];
  879.     LookUpType;
  880.     if FOUND= -1 then AddType;
  881.     T[0]:=FOUND;
  882.     for I:= 1 to 7 do
  883.     begin
  884.       Xs:=LIs[I];
  885.       LookUpSignalName;
  886.       if FOUND= -1 then AddNameToList;
  887.       T[I]:= FOUND;
  888.     end;
  889.     AddT0thruT7toLogicArray;
  890.   until T[0]=0;
  891. end; {of ReadInLogicDescription}
  892.  
  893. Procedure Initialize;
  894.  Begin
  895.   NLGIC:=0; NTYPE:=14; NPRIM:=13; MX:=MTYPES;
  896.   TYPES[0] :='END';        TYPES[1]:='AND';          TYPES[2]:='NAND';
  897.   TYPES[3] :='OR';         TYPES[4]:='NOR';          TYPES[5]:='XOR';
  898.   TYPES[6] :='XNOR';       TYPES[7]:='DFF';          TYPES[8]:='JKFF';
  899.   TYPES[9] :='CNTR';       TYPES[10]:='PLSR';        TYPES[11]:='SREG';
  900.   TYPES[12]:='*';
  901.  
  902.   LOGIN[L0]:='0';      LOGPR[L0]:='.';       LNOT[L0]:=L1;      LV[L0]:=L0;
  903.   LOGIN[L1]:='1';      LOGPR[L1]:='1';       LNOT[L1]:=L0;      LV[L1]:=L1;
  904.   LOGIN[Lx]:='X';      LOGPR[Lx]:='?';       LNOT[Lx]:=Lx;      LV[Lx]:=Lx;
  905.   TEX[0]:='A';       TEX[1]:='P';
  906.  end; {of initialization }
  907.  
  908. Procedure CheckForMacroErrors;
  909. begin
  910.   Writeln('*****       Checking macro ',TYPES[MX],' for Errors');
  911.   X1:=TYPEX[MX];
  912.   ClearOldArray;
  913.   repeat
  914.     for I:=1 to 5 do
  915.     begin
  916.       X:=LO[X1,I];
  917.       MarkOutputsAndCheckForDupes;
  918.     end;
  919.     X1:=X1+1;
  920.     X:=LO[X1,0];
  921.   until TYPES[X]<>'*';
  922.   STF:=X1;
  923.   CheckForMultipleOutputs;
  924.   CheckForDefinedInputs;
  925.   ERROR:=0
  926. end; {of CheckForMacroErrors}
  927.  
  928. Procedure ReadMacros;
  929. LABEL NextMacro;
  930. begin
  931.   NextMacro:
  932.   ReadAndParse;
  933.   if Copy(LIs[0],1,3) = 'MAC' then
  934.   begin
  935.     Xs:=LIs[1];
  936.     Writeln('*****       Reading in macro: ',Xs);
  937.     Header:='Macro: '+Xs;
  938.     WriteHeader;
  939.     TPTR:=-1;
  940.     LookUpType;
  941.     if FOUND<> -1 then
  942.     begin
  943.       if TPTR<> -1 then
  944.       begin
  945.         Writeln('This Macro name Already exists. Should it be replaced?');
  946.         Write('(R)eplace, (N)oReplace ');
  947.         Readln(ASK); ASK:= ASK+' ';
  948.         ASK:= upcase(copy(ASK,1,1));
  949.         if ASK<>'R' then
  950.         begin
  951.           repeat
  952.             ReadAndParse;
  953.           until LIs[0]='END';
  954.         end;
  955.         GOTO NextMacro;
  956.       end;
  957.     end;
  958.     TPTR:=NLGIC;
  959.     AddType;
  960.     MX:=FOUND;
  961.     ReadInLogicDescription;
  962.     CheckForMacroErrors;
  963.   GOTO nextMacro;
  964.   end;
  965. end; {of ReadInMacros}
  966.  
  967. Procedure ExpandMacros;
  968. begin
  969.   repeat
  970.     STF:=SLGIC; FM:=0;
  971.     for I:=STF to NLGIC-1 do
  972.     begin
  973.       if LO[I,0]>NPRIM then
  974.       begin
  975.         BuildMacroCorrespondenceArray;
  976.         AddExpandedMacroToElementArray;
  977.         FM:=1;
  978.       end;
  979.     end;
  980.   until FM=0
  981. end; {of ExpandMacros}
  982.  
  983. Procedure ListExpansion;
  984. begin
  985.   Header:='Expanded Logic Description';
  986.   WriteHeader;
  987.   Writeln(Device,'TYPE','INPUTS':22,'OUTPUTS':29);
  988.   for I:=1 to 5 do
  989.   begin
  990.     Write(Device,I:8);
  991.   end;
  992.   Writeln(Device,'Q':8,'Q-':8);
  993.   NAMES[0]:=' ';
  994.   for I:= SLGIC to NLGIC-1 do
  995.   begin
  996.     Write(Device,TYPES[LO[I,0]]:8);
  997.     for II:= 1 to 7 do
  998.     begin
  999.       XX:=LO[I,II];
  1000.       if XX<0 then Write(Device,'#':8,-XX);
  1001.       if XX>=0 then Write(Device,NAMES[XX]:8);
  1002.     end;
  1003.     Writeln(Device);
  1004.   end;
  1005.   NAMES[0]:='0';
  1006. end;  {of ListExpansion}
  1007.  
  1008.